// import { _decorator, Component, Label, ProgressBar } from 'cc';
// import { bundleManager, IBundleConfig } from './bundleManager';
// import { bundlePool } from './bundlePoolIntegration';
// import { nodePoolManager } from '../nodepool/NodepoolManager';

// const { ccclass, property } = _decorator;

// /**
//  * 资源包管理器使用示例
//  */
// @ccclass('BundleManagerExample')
// export class BundleManagerExample extends Component {
//     @property(Label)
//     statusLabel: Label = null!;

//     @property(ProgressBar)
//     progressBar: ProgressBar = null!;

//     async start() {
//         this.log('资源包管理器示例启动');

//         // 示例1: 基础使用
//         await this.example1_BasicUsage();

//         // 示例2: 批量加载
//         await this.example2_BatchLoad();

//         // 示例3: 依赖管理
//         await this.example3_Dependencies();

//         // 示例4: 引用计数
//         await this.example4_RefCount();

//         // 示例5: 统计信息
//         this.example5_Statistics();
//     }

//     /**
//      * 示例1: 基础使用
//      */
//     private async example1_BasicUsage() {
//         this.log('\n===== 示例1: 基础使用 =====');

//         // 注册资源包
//         bundleManager.registerBundle({
//             name: 'test1',
//             priority: 10,
//         });

//         // 加载资源包
//         const bundle = await bundleManager.loadBundle(
//             'test1',
//             (name, progress) => {
//                 this.log(`${name} 加载进度: ${(progress * 100).toFixed(2)}%`);
//             }
//         );

//         if (bundle) {
//             this.log('资源包 test1 加载成功');
//         }

//         // 获取资源包
//         const cached = bundleManager.getBundle('test1');
//         this.log(`从缓存获取: ${cached ? '成功' : '失败'}`);

//         // 检查是否已加载
//         const hasBundle = bundleManager.hasBundle('test1');
//         this.log(`资源包已加载: ${hasBundle}`);
//     }

//     /**
//      * 示例2: 批量加载
//      */
//     private async example2_BatchLoad() {
//         this.log('\n===== 示例2: 批量加载 =====');

//         // 注册多个资源包
//         const configs: IBundleConfig[] = [
//             { name: 'common', priority: 100 },
//             { name: 'ui', priority: 50 },
//             { name: 'game', priority: 10 },
//         ];

//         bundleManager.registerBundles(configs);

//         // 批量加载
//         const results = await bundleManager.loadBundles(
//             ['common', 'ui', 'game'],
//             (loaded, total) => {
//                 const progress = loaded / total;
//                 this.updateProgress(progress);
//                 this.log(`批量加载进度: ${loaded}/${total}`);
//             }
//         );

//         this.log(`批量加载完成，成功: ${results.size}`);
//     }

//     /**
//      * 示例3: 依赖管理
//      */
//     private async example3_Dependencies() {
//         this.log('\n===== 示例3: 依赖管理 =====');

//         // 注册带依赖的资源包
//         bundleManager.registerBundle({
//             name: 'level1',
//             dependencies: ['common', 'ui'],  // 依赖 common 和 ui
//         });

//         this.log('开始加载 level1（自动加载依赖）');
//         const bundle = await bundleManager.loadBundle('level1');

//         if (bundle) {
//             this.log('level1 加载成功');
//             this.log('依赖资源包也已加载');

//             // 验证依赖是否已加载
//             const hasCommon = bundleManager.hasBundle('common');
//             const hasUi = bundleManager.hasBundle('ui');
//             this.log(`common: ${hasCommon}, ui: ${hasUi}`);
//         }
//     }

//     /**
//      * 示例4: 引用计数
//      */
//     private async example4_RefCount() {
//         this.log('\n===== 示例4: 引用计数 =====');

//         const bundleName = 'test_refcount';

//         // 注册资源包
//         bundleManager.registerBundle({ name: bundleName });
//         await bundleManager.loadBundle(bundleName);

//         // 获取初始信息
//         let info = bundleManager.getBundleInfo(bundleName);
//         this.log(`初始引用计数: ${info?.refCount}`);

//         // 增加引用
//         bundleManager.retainBundle(bundleName);
//         bundleManager.retainBundle(bundleName);
//         info = bundleManager.getBundleInfo(bundleName);
//         this.log(`增加引用后: ${info?.refCount}`);

//         // 减少引用
//         bundleManager.releaseBundle(bundleName);
//         info = bundleManager.getBundleInfo(bundleName);
//         this.log(`减少引用后: ${info?.refCount}`);

//         // 减少引用并自动卸载
//         bundleManager.releaseBundle(bundleName, true);
//         bundleManager.releaseBundle(bundleName, true);
//         info = bundleManager.getBundleInfo(bundleName);
//         this.log(`引用为0时状态: ${info?.state}`);
//     }

//     /**
//      * 示例5: 统计信息
//      */
//     private example5_Statistics() {
//         this.log('\n===== 示例5: 统计信息 =====');

//         // 获取统计信息
//         const stats = bundleManager.getStatistics();
//         this.log(`总资源包数: ${stats.total}`);
//         this.log(`已加载: ${stats.loaded}`);
//         this.log(`加载中: ${stats.loading}`);
//         this.log(`失败: ${stats.failed}`);
//         this.log(`总引用数: ${stats.totalRefCount}`);

//         // 打印详细信息
//         bundleManager.printBundleInfos();
//     }

//     /**
//      * 辅助方法：更新进度条
//      */
//     private updateProgress(progress: number) {
//         if (this.progressBar) {
//             this.progressBar.progress = progress;
//         }
//     }

//     /**
//      * 辅助方法：日志输出
//      */
//     private log(message: string) {
//         console.log(message);
//         if (this.statusLabel) {
//             this.statusLabel.string += message + '\n';
//         }
//     }
// }

// /**
//  * 资源包节点池集成示例
//  */
// @ccclass('BundlePoolExample')
// export class BundlePoolExample extends Component {
//     async start() {
//         // 示例1: 创建资源包节点池
//         await this.example1_CreatePool();

//         // 示例2: 批量创建
//         await this.example2_BatchCreate();

//         // 示例3: 使用节点池
//         this.example3_UsePool();

//         // 示例4: 资源包联动
//         this.example4_BundleIntegration();
//     }

//     /**
//      * 示例1: 创建资源包节点池
//      */
//     private async example1_CreatePool() {
//         console.log('\n===== 示例1: 创建资源包节点池 =====');

//         // 创建节点池
//         const success = await bundlePool.createPool('enemy', {
//             bundleName: 'game',
//             prefabPath: 'prefabs/enemy',
//             preloadCount: 10,
//             maxCount: 50,
//             onNodeReuse: (node) => {
//                 console.log('节点重用:', node.name);
//             },
//         });

//         console.log(`节点池创建: ${success ? '成功' : '失败'}`);
//     }

//     /**
//      * 示例2: 批量创建
//      */
//     private async example2_BatchCreate() {
//         console.log('\n===== 示例2: 批量创建节点池 =====');

//         const results = await bundlePool.createPools([
//             {
//                 poolId: 'bullet',
//                 config: {
//                     bundleName: 'game',
//                     prefabPath: 'prefabs/bullet',
//                     preloadCount: 20,
//                     maxCount: 100,
//                 },
//             },
//             {
//                 poolId: 'particle',
//                 config: {
//                     bundleName: 'game',
//                     prefabPath: 'prefabs/particle',
//                     preloadCount: 5,
//                     maxCount: 20,
//                 },
//             },
//         ]);

//         console.log('批量创建结果:', results);
//     }

//     /**
//      * 示例3: 使用节点池
//      */
//     private example3_UsePool() {
//         console.log('\n===== 示例3: 使用节点池 =====');

//         // 获取节点
//         const enemy = nodePoolManager.getNode('enemy');
//         if (enemy) {
//             this.node.addChild(enemy);
//             enemy.setPosition(0, 0, 0);
//             console.log('从池中获取敌人节点');

//             // 使用完后回收
//             this.scheduleOnce(() => {
//                 nodePoolManager.putNode(enemy);
//                 console.log('敌人节点已回收');
//             }, 2);
//         }
//     }

//     /**
//      * 示例4: 资源包联动
//      */
//     private example4_BundleIntegration() {
//         console.log('\n===== 示例4: 资源包联动 =====');

//         // 按资源包分组查看节点池
//         const groups = bundlePool.getPoolsByBundle();
//         groups.forEach((poolIds, bundleName) => {
//             console.log(`资源包 ${bundleName} 的节点池:`, poolIds);
//         });

//         // 打印详细信息
//         bundlePool.printPoolInfo();
//     }
// }

// /**
//  * 完整的游戏启动流程示例
//  */
// @ccclass('GameStarterExample')
// export class GameStarterExample extends Component {
//     @property(Label)
//     loadingLabel: Label = null!;

//     @property(ProgressBar)
//     loadingProgress: ProgressBar = null!;

//     async start() {
//         await this.startGame();
//     }

//     private async startGame() {
//         try {
//             // 1. 注册资源包
//             this.updateLoading('注册资源包...', 0.1);
//             this.registerBundles();

//             // 2. 加载核心资源包
//             this.updateLoading('加载资源包...', 0.2);
//             await this.loadCoreBundles();

//             // 3. 创建节点池
//             this.updateLoading('创建节点池...', 0.7);
//             await this.createNodePools();

//             // 4. 完成
//             this.updateLoading('加载完成！', 1.0);
//             this.onLoadComplete();

//         } catch (error) {
//             console.error('游戏启动失败:', error);
//             this.updateLoading('加载失败！', 0);
//         }
//     }

//     private registerBundles() {
//         bundleManager.registerBundles([
//             { name: 'common', priority: 100, autoLoad: true },
//             { name: 'ui', priority: 50, dependencies: ['common'] },
//             { name: 'game', priority: 10, dependencies: ['common', 'ui'] },
//             { name: 'audio', priority: 5 },
//         ]);
//     }

//     private async loadCoreBundles() {
//         const bundles = ['common', 'ui', 'game'];
//         let baseProgress = 0.2;
//         const progressStep = 0.5 / bundles.length;

//         await bundleManager.loadBundles(bundles, (loaded, total) => {
//             const progress = baseProgress + (loaded / total) * 0.5;
//             this.updateLoading(`加载资源包... (${loaded}/${total})`, progress);
//         });
//     }

//     private async createNodePools() {
//         await bundlePool.createPools([
//             {
//                 poolId: 'enemy',
//                 config: {
//                     bundleName: 'game',
//                     prefabPath: 'prefabs/enemy',
//                     preloadCount: 10,
//                     maxCount: 50,
//                 },
//             },
//             {
//                 poolId: 'bullet',
//                 config: {
//                     bundleName: 'game',
//                     prefabPath: 'prefabs/bullet',
//                     preloadCount: 20,
//                     maxCount: 100,
//                 },
//             },
//         ]);

//         // 预加载节点池
//         await bundlePool.preloadBundlePools('game');
//     }

//     private updateLoading(message: string, progress: number) {
//         console.log(`[${(progress * 100).toFixed(2)}%] ${message}`);

//         if (this.loadingLabel) {
//             this.loadingLabel.string = message;
//         }

//         if (this.loadingProgress) {
//             this.loadingProgress.progress = progress;
//         }
//     }

//     private onLoadComplete() {
//         console.log('游戏启动完成！');

//         // 打印统计信息
//         bundleManager.printBundleInfos();
//         bundlePool.printPoolInfo();

//         // 进入游戏主场景...
//     }

//     onDestroy() {
//         // 清理资源
//         bundlePool.removeAllPools(false);
//         bundleManager.cleanupUnusedBundles();
//     }
// }

